#include "mypthread.hpp"
#include "mymutex.hpp"

class PthreadData
{
public:
    // PthreadData(const string& pthreadname, pthread_mutex_t* mutexp)
    // :_pthreadname(pthreadname)
    // ,_mutexp(mutexp)
    // {}

    PthreadData(const string& pthreadname, pthread_rwlock_t* lock)
    :_pthreadname(pthreadname)
    ,_lock(lock)
    {}


    ~PthreadData()
    {}


public:
    string _pthreadname;
    //pthread_mutex_t* _mutexp;
    pthread_rwlock_t* _lock;
};


//模拟抢票
int g_ticket = 1000;

// void* get_ticket(void* args)
// {
//     //string username = static_cast<const char*>(args);
//     PthreadData* pd = static_cast<PthreadData*>(args);
//     pthread_mutex_t* lock = pd->_mutexp;
//     string username = pd->_pthreadname;
//     while(1)
//     {
//         //加锁和解锁的过程就是让线程互斥串行执行，程序速度变慢了

//         {
//             //pthread_mutex_lock(lock);
//             LockGuard lockguard(lock);
//             if(g_ticket > 0)
//             {
//                 usleep(1234);
//                 cout << username << ":正在抢票:" << g_ticket << endl;
//                 g_ticket--;
//                 //usleep(1234);
//                 //pthread_mutex_unlock(lock);
//             }
//             else 
//             {
//             //pthread_mutex_unlock(lock);
//                 break;
//             }
//         } //lockguard自动释放，解锁

//         //to do
//     }
// }


void* get_ticket(void* args)
{
    PthreadData* pd = static_cast<PthreadData*>(args);
    pthread_rwlock_t* lock = pd->_lock;
    string username = pd->_pthreadname;
    while(1)
    {
        if(g_ticket > 0)
        {
            pthread_rwlock_wrlock(lock);
            if(g_ticket > 0)
            {
                usleep(1234);
                cout << username << ":正在抢票:" << g_ticket << endl;
                g_ticket--;
            }
            else 
            {
                pthread_rwlock_unlock(lock);
                break;
            }
            pthread_rwlock_unlock(lock);
        }
        else
            break;
    }
}


#define NUM 4
int main()
{
    vector<pthread_t> tids(NUM);
    // pthread_mutex_t lock;
    // pthread_mutex_init(&lock,nullptr);
    pthread_rwlock_t lock;
    pthread_rwlock_init(&lock,nullptr);
    for(int i = 0; i < NUM; i++)
    {
        char buffer[1024];
        snprintf(buffer,sizeof buffer,"pthreadname->%d",i+1);
        PthreadData* pd = new PthreadData(string(buffer),&lock); //记录锁，方便所有进程共用一个锁
        pthread_create(&tids[i],nullptr,get_ticket,pd);//创建线程
    }

    for(int i = 0; i < NUM; i++)
    {
        pthread_join(tids[i],nullptr);
    }
    pthread_rwlock_destroy(&lock);

    // //有四个进程进行抢票
    // unique_ptr<Pthread> thread1(new Pthread(get_ticket,(void*)"user1",1));
    // unique_ptr<Pthread> thread2(new Pthread(get_ticket,(void*)"user2",2));
    // unique_ptr<Pthread> thread3(new Pthread(get_ticket,(void*)"user3",3));
    // unique_ptr<Pthread> thread4(new Pthread(get_ticket,(void*)"user4",4));

    // thread1->join();
    // thread2->join();
    // thread3->join();
    // thread4->join();



    return 0;
}





// void* start_routine(void* args)
// {
//     //pthread_detach(pthread_self()); //设置自己为分离，有风险
//     const char* name = (const char*)args;
//     while(1)
//     {
//         cout << "我是新线程，我正在执行任务:" << name << " 我的线程tid是:" << pthread_self() << endl; 
//         sleep(1); 
//     }

//     //pthread_exit(nullptr);

//     return (void*)100;
// }


// int main()
// {

//     //创建线程
//     pthread_t tid;
//     int n = pthread_create(&tid,nullptr,start_routine,(void*)"hello world!"); //创建新线程
//     assert(1);
//     (void)n;
//     sleep(5);
//     //pthread_exit(nullptr);
//     pthread_cancel(pthread_self());





//     // sleep(7);
//     // pthread_join(tid,nullptr);

//     // 我们希望新线程在结束的时候能够自动释放其资源
//     // pthread_detach(tid); //线程分离
//     // cout << "线程等待中，等待的线程tid: " << tid << endl;
//     // void* ptr;
//     // int ans = pthread_join(tid,&ptr); //线程等待
        //一个线程默认是joinable的，如果分离，就不能进行等待了
//     // if(ans == 0)
//     //     cout << "线程等待成功" << endl;
//     // else 
//     //     cout << "线程分离" << endl;




//     // 当新线程在跑的时候，主线程就会进行阻塞等待
//     // cout << "线程等待中，等待的线程tid: " << tid << endl;
//     // void* ptr;
//     // pthread_join(tid,&ptr); //线程等待
//     // cout << "线程等待成功!" << endl;





//     // 线程终止,线程如果被终止，退出码是-1
//     // int cnt = 10;
//     // while(cnt--)
//     // {
//     //     cout << "我是主线程，我正在执行循环" << endl;
//     //     sleep(1);
//     // }
//     // int ans = pthread_cancel(tid);
//     // cout << "进程终止成功,它的tid为:" << tid << endl; 
//     // void* ptr;
//     // pthread_join(tid,(void**)&ptr); //线程等待
//     // cout << (long long)ptr << endl;
//     // sleep(5);


//     return 0;
// }